home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / internet / irc_i_dodatki / eggdrop / eggdrop11.lha / scripts / wire.tcl < prev   
Text File  |  1997-01-15  |  11KB  |  360 lines
  1. #
  2. #  wire v1.33
  3. #    secondary encrypted communications on a botnet
  4. #    based on wire 1.0 by Robey Pointer
  5. #    11 September 1996 by Gord-@saFyre
  6. #    updated 17 September 1996 by Gord-@saFyre
  7. #    updated 31 October 1996 by Gord-@saFyre
  8. #    updated 4 November 1996 by Gord-@saFyre
  9. #
  10. # requires at least eggdrop v1.0i+
  11. #
  12. # to initiate a secure communications link, decide on
  13. # a common password between you and the people you want
  14. # to talk to, then issue the command ".wire <password>"
  15. # all lines starting with a semi-colon ";" will go
  16. # to the wire.
  17. #
  18. # .wire <encrypt-key>   initiates a wire session
  19. #
  20. # .onwire    will return the handle@bot of all other
  21. #            users on the same wire
  22. #
  23.  
  24. # initialize arrays
  25. # idx -> encrypt-key
  26. set wire(*) "*"
  27. # $wire_cmd -> idx list
  28. set wired(*) "*"
  29.  
  30. if {[lindex $version 1] < 1081} {
  31.   putlog "* Can't load wire -- needs at least v1.0h+"
  32. } {
  33.   bind dcc - wire do_wire
  34.   bind filt - ";*" filt_wire
  35.   bind chof - * chof_wire
  36.   bind dcc - onwire onwire
  37.   bind fil - onwire onwire
  38. }
  39.  
  40. # join the wire
  41. proc do_wire {hand idx arg} {
  42.   global wire wired nick
  43.   if {$arg == ""} {
  44.     putdcc $idx "Usage: .wire <encrypt-key>|OFF"
  45.     if {[info exists wire($idx)]} {
  46.       putdcc $idx "You are currently on wire '$wire($idx)'."
  47.     }
  48.     return 0
  49.   }
  50.   if {($arg == "off") || ($arg == "OFF")} {
  51.     if {![info exists wire($idx)]} {
  52.       putdcc $idx "That's nice, but you weren't on the wire anyway."
  53.       return 0
  54.     }
  55.     set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  56.     set x [encrypt $wire($idx) "$hand left the wire."]
  57.     putwire $wire_cmd $idx "----- " $x
  58.     putallbots "$wire_cmd $nick $x"
  59.     unset wire($idx)
  60.     set wired($wire_cmd) [lreplace $wired($wire_cmd) [lsearch $wired($wire_cmd) $idx] [lsearch $wired($wire_cmd) $idx]]
  61.     if {![llength $wired($wire_cmd)]} {
  62.       unset wired($wire_cmd)
  63.       unbind bot - $wire_cmd bot_wire
  64.     }
  65.     putdcc $idx "You are now off the wire."
  66.     return 0
  67.   }
  68.   if {[info exists wire($idx)]} {
  69.     putdcc $idx "Changing encryption key ..."
  70.     set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  71.     set x [encrypt $wire($idx) "$hand left the wire."]
  72.     putwire $wire_cmd $idx "----- " $x
  73.     putallbots "$wire_cmd $nick $x"
  74.     unset wire($idx)
  75.     set wired($wire_cmd) [lreplace $wired($wire_cmd) [lsearch $wired($wire_cmd) $idx] [lsearch $wired($wire_cmd) $idx]]
  76.     if {![llength $wired($wire_cmd)]} {
  77.       unset wired($wire_cmd)
  78.       unbind bot - $wire_cmd bot_wire
  79.     }
  80.   }
  81.   set wire($idx) $arg
  82.   set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  83.   if {[info exists wired($wire_cmd)]} {
  84.     set wired($wire_cmd) [lappend wired($wire_cmd) $idx]
  85.   } {
  86.     set wired($wire_cmd) $idx
  87.     bind bot - $wire_cmd bot_wire
  88.   }  
  89.   putdcc $idx "----- All text starting with ; will now go over the wire."
  90.   putdcc $idx "----- To see who's on your wire, type '.onwire'."
  91.   putdcc $idx "----- To leave, type '.wire off'."
  92.   set x [encrypt $wire($idx) "$hand joined wire '$wire($idx)'."]
  93.   putwire $wire_cmd $idx "----- " $x
  94.   putallbots "$wire_cmd $nick $x"
  95.   onwire $hand $idx $arg
  96.   return 0
  97. }
  98.  
  99. proc filt_wire {idx text} {
  100.   global wire nick
  101.   if {![info exists wire($idx)]} { return 0 }
  102.   set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  103.   set hand [idx2hand $idx]
  104.   if {([string compare [string tolower [string range $text 1 2]] "me"] == 0) && ![isalphanum [string index $text 3]]} {
  105.     set text [string range $text 2 end]
  106.     set inhand "----- > $hand"
  107.     set outhand "!${hand}@$nick"
  108.   } {
  109.     set inhand "----- <$hand> "
  110.     set outhand "${hand}@$nick"
  111.   }
  112.   set x [encrypt $wire($idx) [string range $text 1 end]]
  113.   putwire $wire_cmd $idx $inhand $x
  114.   putallbots "$wire_cmd $outhand $x"
  115.   return 1
  116. }
  117.  
  118. # people vanishing who might still be on the wire
  119. proc chof_wire {hand idx} {
  120.   global wired wire nick
  121.   if {[info exists wire($idx)]} {
  122.     set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  123.     set x [encrypt $wire($idx) "$hand left the wire."]
  124.     putwire $wire_cmd $idx "----- " $x
  125.     putallbots "$wire_cmd $nick $x"
  126.     unset wire($idx)
  127.     set wired($wire_cmd) [lreplace $wired($wire_cmd) [lsearch $wired($wire_cmd) $idx] [lsearch $wired($wire_cmd) $idx]]
  128.     if {![llength $wired($wire_cmd)]} {
  129.       unset wired($wire_cmd)
  130.       unbind bot - $wire_cmd bot_wire
  131.     }
  132.   }
  133. }
  134.  
  135. # who else is on the same wire with you?
  136. proc onwire {handle idx arg} {
  137.   global wire wired nick version
  138.   if {![info exists wire($idx)]} {
  139.     putdcc $idx "You aren't on a wire."
  140.     return 0 
  141.   }
  142.   set wire_cmd "!wire[encrypt $wire($idx) "wire"]"
  143.   set x [encrypt $wire($idx) $handle]
  144.   putdcc $idx "----- Currently on wire '$wire($idx)':"
  145.   putdcc $idx "----- Nick       Bot        Host"
  146.   putdcc $idx "----- ---------- ---------- ------------------------------"
  147.   putallbots "$wire_cmd !wirereq $idx $x"
  148.   foreach j [dcclist] {
  149.     append jlist " [lindex $j 0]"
  150.   }
  151.   foreach i $wired($wire_cmd) {
  152.     if {($i != "*") && ([lsearch $jlist $i] != -1)} {
  153.       set hand [idx2hand $i]
  154.       set attr " "
  155.       if {[matchattr $hand o]} {set attr "@"}
  156.       if {[matchattr $hand m]} {set attr "+"}
  157.       if {[matchattr $hand n]} {set attr "*"}
  158.       set outline "----- ${attr}${hand}"
  159.       for {set r [string length $hand]} {$r < 10} {incr r} {
  160.         append outline " "
  161.       }
  162.       append outline $nick
  163.       for {set r [string length $nick]} {$r < 11} {incr r} {
  164.         append outline " "
  165.       }
  166.       foreach j [dcclist] {
  167.         if {[lindex $j 0] == $i} {
  168.           append outline [lindex $j 2]
  169.           break
  170.          }
  171.       }
  172.       if {[getdccidle $i] >= 300} {
  173.         set idletime [expr [getdccidle $i] / 60]
  174.         if {$idletime >= 60} {
  175.           set idlehour [expr $idletime / 60]
  176.           set idlemin [expr $idletime % 60]
  177.           if {$idlehour >= 24} {
  178.             set idleday [expr $idlehour / 24]
  179.             set idlehour2 [expr $idlehour % 24]
  180.             set idlehour "${idleday}d${idlehour2}"
  181.           }
  182.           set idletime "${idlehour}h${idlemin}"
  183.         }
  184.         append outline " \[idle ${idletime}m\]"
  185.       }
  186.       putdcc $idx $outline
  187.       if {([lindex $version 1] >= 1094) && ([getdccaway $i] != "")} {
  188.         putdcc $idx "-----    AWAY: [getdccaway $i]"
  189.       }
  190.     }
  191.   }
  192. }
  193.  
  194. # incoming from other bots
  195. proc bot_wire {from cmd text} {
  196.   global wire wired nick version
  197.   set header [lindex $text 0]
  198.   set encrypted [lindex $text 1]
  199.   if {[string first @ $header] == -1} {
  200.     if {$header == "!wirereq"} {
  201.       set fidx [lindex $text 1]
  202.       set fhand [lindex $text 2]
  203.       if {![info exists wired($cmd)]} {return 0}
  204.       set jlist "*"
  205.       foreach j [dcclist] {
  206.         append jlist " [lindex $j 0]"
  207.       }
  208.       foreach i $wired($cmd) {
  209.         if {($i != "*") && ([lsearch $jlist $i] != -1)} {
  210.           set hand [idx2hand $i]
  211.           set attr " "
  212.           if {[matchattr $hand o]} {set attr "@"}
  213.           if {[matchattr $hand m]} {set attr "+"}
  214.           if {[matchattr $hand n]} {set attr "*"}
  215.           set outline "----- ${attr}${hand}"
  216.           for {set r [string length $hand]} {$r < 10} {incr r} {
  217.             append outline " "
  218.           }
  219.           append outline $nick
  220.           for {set r [string length $nick]} {$r < 11} {incr r} {
  221.             append outline " "
  222.           }
  223.           foreach j [dcclist] {
  224.             if {[lindex $j 0] == $i} {
  225.               append outline [lindex $j 2]
  226.               break
  227.              }
  228.           }
  229.           if {[getdccidle $i] >= 300} {
  230.             set idletime [expr [getdccidle $i] / 60]
  231.             if {$idletime >= 60} {
  232.               set idlehour [expr $idletime / 60]
  233.               set idlemin [expr $idletime % 60]
  234.               if {$idlehour >= 24} {
  235.                 set idleday [expr $idlehour / 24]
  236.                 set idlehour2 [expr $idlehour % 24]
  237.                 set idlehour "${idleday}d${idlehour2}"
  238.               }
  239.               set idletime "${idlehour}h${idlemin}"
  240.             }
  241.             append outline " \[idle ${idletime}m\]"
  242.           }
  243.           set x [encrypt $wire($i) $outline]
  244.           putbot $from "$cmd !wireresp $fidx $fhand $x"
  245.           if {([lindex $version 1] >= 1094) && ([getdccaway $i] != "")} {
  246.             set x [encrypt $wire($i) "-----    AWAY: [getdccaway $i]"]
  247.             putbot $from "$cmd !wireresp $fidx $fhand $x"
  248.           }
  249.         }
  250.       }
  251.       return 0
  252.     }
  253.     if {$header == "!wireresp"} {
  254.       set fidx [lindex $text 1]
  255.       set xhand [lindex $text 2]
  256.       set xresp [lindex $text 3]
  257.       if {![info exists wired($cmd)]} {return 0}
  258.       if {[lsearch -exact $wired($cmd) $fidx] == -1} {return 0}
  259.       if {[idx2hand $fidx] != [decrypt $wire($fidx) $xhand]} {return 0}
  260.       putdcc $fidx [decrypt $wire($fidx) $xresp]
  261.       return 0
  262.     }
  263.     set header "($header) "
  264.   } {
  265.     if {[string index $header 0] == "!"} {
  266.       set header "> [string range $header 1 end]"
  267.     } {
  268.       set header "<$header> "
  269.     }
  270.   }
  271.   putwire $cmd -1 "----- $header" $encrypted
  272. }
  273.  
  274. # display to local user (still encrypted)
  275. proc putwire {cmd idx header text} {
  276.   global wire wired
  277.   if {![info exists wired($cmd)]} {return 0}
  278.   set jlist "*"
  279.   set clist "*"
  280.   foreach j [dcclist] {
  281.     append jlist " [lindex $j 0]"
  282.     if {[lindex $j 3] == "chat"} {
  283.       append clist " [lindex $j 0]"
  284.     }
  285.   }
  286.   foreach i $wired($cmd) {
  287.     if {($i != "*") && ([lsearch $jlist $i] != -1)} {
  288.       if {($i != $idx) || ([lsearch $clist $i] == -1) || ([echo $i] == 1)} {
  289.         set x [decrypt $wire($i) $text]
  290.         putdcc $i "${header}$x"
  291.       }
  292.     }
  293.   }
  294. }
  295.  
  296. proc isalphanum {arg} {
  297.   if {[string length $arg] == 0} {return 0}
  298.   set ctr 0
  299.   while {$ctr < [string length $arg]} {
  300.     if {![string match \[0-9a-zA-Z\] [string index $arg $ctr]]} {return 0}
  301.     set ctr [expr $ctr + 1]
  302.   }
  303.   return 1
  304. }
  305.  
  306. proc gordver_wire {} {
  307.   return "wire.tcl v1.33"
  308. }
  309.  
  310. #### These commands will be included in all scriptpacks released by
  311. #### Gord-@saFyre as of 15 April 1996.  In combination with a 
  312. #### gordver_* process for each scriptpack, it will provide you
  313. #### with a way to determine what versions you or other bots
  314. #### currently have loaded.  The command .checkver will return
  315. #### a list of the loaded scripts and versions. The command
  316. #### .checkver <bot> will return that info for the remote <bot>
  317.  
  318. proc checkver {} {
  319.   set response { }
  320.   foreach process [info procs gordver*] {
  321.     lappend response [$process]
  322.   }
  323.   return [lsort $response]
  324. }
  325.  
  326. bind dcc m checkver dcc_checkver
  327. proc dcc_checkver {hand idx arg} {
  328.   global botnick
  329.   putcmdlog "#$hand# checkver $arg"
  330.   if {[llength $arg] == 0} {
  331.     putdcc $idx "*** The following scriptpacks by Gord-@saFyre are loaded:"
  332.     foreach pack [checkver] {
  333.       putdcc $idx "*** $pack"
  334.     }
  335.     putdcc $idx "*** End of list."
  336.     return 0
  337.   }
  338.   foreach bot $arg {
  339.     if {[lsearch [string tolower [bots]] [string tolower $bot]] == -1} {
  340.       putdcc $idx "*** $bot is not a linked bot!"
  341.     } {
  342.       putbot $bot "checkver $hand"
  343.     }
  344.   }
  345.   return 0
  346. }
  347.  
  348. bind bot - checkver bot_checkver
  349. proc bot_checkver {bot cmd arg} {
  350.   global botnick
  351.   set from [lindex $arg 0]
  352.   sendnote $botnick "$from@$bot" "The following scriptpacks by Gord-@saFyre are loaded:"
  353.   foreach pack [checkver] {
  354.     sendnote $botnick "$from@$bot" $pack
  355.   }
  356.   sendnote $botnick "$from@$bot" "End of list."
  357.   return 0
  358. }
  359.  
  360.